Rete Neurale¶
Caricamento delle librerie
In [1]:
import os
import pandas as pd
from numpy import loadtxt
import numpy as np
import datetime
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import time
# For LSTM model
from keras.models import Sequential
from keras.layers import Dense
from keras.layers import LSTM
from keras.layers import Dropout
from keras.callbacks import EarlyStopping
from keras.models import load_model
#from ann_visualizer.visualize import ann_viz
from keras.utils.vis_utils import plot_model
import plotly.graph_objects as go
import plotly.express as px
import plotly.io as pio
# Themes
# "seaborn", 'ggplot2', 'seaborn', 'simple_white', 'plotly', 'plotly_white', 'plotly_dark', 'presentation', 'xgridoff', 'ygridoff', 'gridon', 'none'
pio.templates.default = "presentation"
from plotly.subplots import make_subplots
Seleziona cartelle e carica file
In [2]:
# select data folder_dati
glob_path = os.path.normpath(os.getcwd() + os.sep + os.pardir)
folder_dati = glob_path+R"//dati"
folder_risultati = glob_path+R"//risultati"
In [3]:
files = os.listdir(folder_risultati)
files[0:]
Out[3]:
In [4]:
# Load df_grouped_date, original file
df = pd.read_csv(folder_risultati+"/df_grouped_date_nosunday.csv", sep = ",")
df2 = pd.read_csv(folder_risultati+"/df_min_ciclo_nosunday_no0.csv", sep = ",")
df = df2
In [5]:
# substitute null values with 0
df['Minuti ciclo'] = df['Minuti ciclo'].fillna(0)
#df['Minuti NO ciclo'] = df['Minuti NO ciclo'].fillna(0)
#df['Efficienza'] = df['Efficienza'].fillna(0)
# convert Date
df['Date'] = pd.to_datetime(df["Date"], format='%Y-%m-%d')
# convert minuti ciclo, no ciclo, efficienza to double
df['Minuti ciclo'] = df['Minuti ciclo'].replace(',', '.', regex=True).astype(float)
#df['Minuti NO ciclo'] = df['Minuti NO ciclo'].replace(',', '.', regex=True).astype(float)
#df['Efficienza'] = df['Efficienza'].replace(',', '.', regex=True).astype(float)
In [6]:
df
Out[6]:
In [7]:
# plot general efficiency
fig = px.line(df, x = "Date", y = "Minuti ciclo",
title = "Efficienza / giorno Totale delle macchine")
fig.show()
Seleziona train e test
In [8]:
train = df[:313]
# Scale features
s1 = MinMaxScaler(feature_range=(-1,1))
Xs = s1.fit_transform(train[['Minuti ciclo']])
# Scale predicted value
s2 = MinMaxScaler(feature_range=(-1,1))
Ys = s2.fit_transform(train[['Minuti ciclo']])
Usa una finestra di osservazioni di 7 giorni per far girare la rete neurale
In [9]:
# Each time step uses last 'window' to predict the next change
window = 6
X = []
Y = []
for i in range(window,len(Xs)):
X.append(Xs[i-window:i,:])
Y.append(Ys[i])
# Reshape data to format accepted by LSTM
X, Y = np.array(X), np.array(Y)
Crea il modello e lo alleni
In [42]:
# create and train LSTM model
# Initialize LSTM model
model1 = Sequential()
model1.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model1.add(Dropout(0.2))
model1.add(LSTM(units=50, return_sequences=True))
model1.add(Dropout(0.2))
model1.add(LSTM(units=50))
model1.add(Dropout(0.2))
model1.add(Dense(units=1))
model1.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
In [43]:
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model1.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
In [44]:
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model1.predict(X)
In [45]:
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
Out[45]:
In [47]:
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse1_train = sqrt(mean_squared_error(Ym, Yu))
rmse1_train
Out[47]:
In [48]:
# Load model
v = model1
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model.predict(Xti)
In [49]:
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
Out[49]:
In [50]:
Ytu
Out[50]:
Calcola indice RMSE
In [51]:
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse1_test = sqrt(mean_squared_error(real, pred))
rmse1_test
Out[51]:
In [52]:
plot_model(model, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
Out[52]:
In [53]:
# second structure
# Initialize LSTM model
model2 = Sequential()
model2.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model2.add(Dropout(0.2))
model2.add(LSTM(units=30))
model2.add(Dropout(0.2))
model2.add(Dense(units=1))
model2.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
In [54]:
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model2.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
In [55]:
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model2.predict(X)
In [56]:
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
Out[56]:
In [57]:
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse2_train = sqrt(mean_squared_error(Ym, Yu))
rmse2_train
Out[57]:
In [58]:
# Load model
v = model2
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model2.predict(Xti)
In [59]:
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
Out[59]:
In [60]:
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse2_test = sqrt(mean_squared_error(real, pred))
rmse2_test
Out[60]:
In [61]:
plot_model(model2, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
Out[61]:
In [82]:
# third structure
# Initialize LSTM model
model3 = Sequential()
model3.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model3.add(Dropout(0.2))
model3.add(LSTM(units=50, return_sequences=True))
model3.add(Dropout(0.2))
model3.add(LSTM(units=40, return_sequences=True))
model3.add(Dropout(0.2))
model3.add(LSTM(units=40))
model3.add(Dropout(0.2))
model3.add(Dense(units=1))
model3.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
In [83]:
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model3.fit(X, Y, epochs = 20, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
In [84]:
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model3.predict(X)
In [85]:
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
Out[85]:
In [86]:
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse3_train = sqrt(mean_squared_error(Ym, Yu))
rmse3_train
Out[86]:
In [87]:
# Load model
v = model3
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model3.predict(Xti)
In [88]:
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
Out[88]:
In [89]:
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse3_test = sqrt(mean_squared_error(real, pred))
rmse3_test
Out[89]:
In [90]:
plot_model(model3, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
Out[90]:
In [72]:
# 4 structure
# Initialize LSTM model
model4 = Sequential()
model4.add(LSTM(units=50, return_sequences=True, \
input_shape=(X.shape[1],X.shape[2])))
model4.add(Dropout(0.2))
model4.add(LSTM(units=50, return_sequences=True))
model4.add(Dropout(0.2))
model4.add(LSTM(units=40, return_sequences=True))
model4.add(Dropout(0.2))
model4.add(LSTM(units=40))
model4.add(Dropout(0.2))
model4.add(Dense(units=1))
model4.compile(optimizer = 'adam', loss = 'mean_squared_error',\
metrics = ['accuracy'])
In [73]:
# Allow for early exit
es = EarlyStopping(monitor='loss',mode='min',verbose=1,patience=10)
# Fit (and time) LSTM model
t0 = time.time()
history = model4.fit(X, Y, epochs = 50, batch_size = 250, callbacks=[es], verbose=1)
t1 = time.time()
print('Runtime: %.2f s' %(t1-t0))
In [74]:
# Plot loss
plt.figure(figsize=(20,4))
plt.semilogy(history.history['loss'])
plt.xlabel('epoch'); plt.ylabel('loss')
# Verify the fit of the model
Yp = model4.predict(X)
In [75]:
# un-scale outputs
Yu = s2.inverse_transform(Yp)
Ym = s2.inverse_transform(Y)
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(train['Date'][window:],Yu,'r-',label='LSTM')
plt.plot(train['Date'][window:],Ym,'k--',label='Real')
plt.ylabel('Minuti ciclo')
plt.legend()
Out[75]:
In [76]:
# RMSE on train
from sklearn.metrics import mean_squared_error
from math import sqrt
rmse4_train = sqrt(mean_squared_error(Ym, Yu))
rmse4_train
Out[76]:
In [77]:
# Load model
v = model4
# Load testing data
test = df[313:497]
Xt = test[['Minuti ciclo']].values
Yt = test[['Minuti ciclo']].values
Xts = s1.transform(Xt)
Yts = s2.transform(Yt)
Xti = []
Yti = []
for i in range(window,len(Xts)):
Xti.append(Xts[i-window:i,:])
Yti.append(Yts[i])
# Reshape data to format accepted by LSTM
Xti, Yti = np.array(Xti), np.array(Yti)
# Verify the fit of the model
Ytp = model4.predict(Xti)
In [78]:
# un-scale outputs
Ytu = s2.inverse_transform(Ytp) # predicted
Ytm = s2.inverse_transform(Yti) # real
plt.figure(figsize=(20,6))
plt.subplot(1,1,1)
plt.plot(test['Date'][window:],Ytu,'r-',label='LSTM Predicted')
plt.plot(test['Date'][window:],Ytm,'k--',label='Real')
plt.legend()
plt.ylabel('Minuti ciclo')
Out[78]:
In [79]:
from sklearn.metrics import mean_squared_error
from math import sqrt
pred = Ytu[:201]
real = Ytm[:201]
rmse4_test = sqrt(mean_squared_error(real, pred))
rmse4_test
Out[79]:
In [80]:
plot_model(model4, to_file='model_plot.png', show_shapes=True, show_layer_names=True)
Out[80]:
In [91]:
print(rmse1_train, rmse1_test, rmse2_train, rmse2_test, rmse3_train, rmse3_test, rmse4_train, rmse4_test)
In [ ]: